Much like with LINQ, this should be passing comparer: null and then we should be treating a null comparer as selecting the default, not throwing.

@tannergooding Should we then update the approved API to explicitly accept a null comparer?

    public T? Min<T>(this ReadOnlySpan<T> span, IComparer<T>? comparer);
    public T? Max<T>(this ReadOnlySpan<T> span, IComparer<T>? comparer);

Nullability annotations are often overlooked in the API review. IComparer<T> parameters is a case that we almost universally allow to be nullable (much like IFormattable, IEqualityComparer, and a couple others) and where we often explicitly want it to be so we can do specific optimizations.

I've left an explicit comment indicating the oversight, so please adjust the PR accordingly.

It's unclear why this deviates from the enumerable logic in implementation.

I'd generally expect the two entry points to be nearly identical. Covering the acceleration and other checks like: https://github.com/dotnet/runtime/blob/main/src/libraries/System.Linq/src/System/Linq/Min.cs#L292-L373

The biggest difference should be that if (!enumerator.MoveNext()) becomes if (i >= span.Length). The JIT should already know that span.Length can't be negative and should know the same of i since we initialize it to 0 and only ever do ++

I have aligned the implementation on the enumerable logic.

Can we reuse the other interface we're adding instead of having two sets?

I did not manage to do it.
IMinMaxCalc<T> where T : struct, IBinaryInteger<T> is a generic interface for integer types and so is not compatible with the IMinMaxDirection one.

Is there still a benefit to having this logic?
It seems like we could remove it any change the caller to use the span.Min directly instead.
E.g. replace this:

if (source.TryGetSpan(out ReadOnlySpan<T> span))
{
    return span.Min(comparer);
}

Nice optimization indeed!

We should be able to delete this file and IMinMaxCalc from Linq, no?

Given that this overload (no comparer) is the expected fast path, it may be better to swap the calls so that it looks more like this instead:

public static T? Min<T>(this ReadOnlySpan<T> span)
{
    if (typeof(T) == typeof(byte)) return MinMaxInteger<T, byte, MinCalc<byte>>(span);
    if (typeof(T) == typeof(sbyte)) return MinMaxInteger<T, sbyte, MinCalc<sbyte>>(span);
    // ...

    return MinMax<T, MinDirection>(span, Comparer<T>.Default);
}

public static T? Min<T>(this ReadOnlySpan<T> span, IComparer<T>? comparer)
{
    if (comparer is null || comparer == Comparer<T>.Default)
    {
        return Max(span);
    }

    return MinMax<T, MinDirection>(span, comparer);
}

So the caller is pretty much guaranteed to call into just the core helper.

Ok, it should reduce comparer checks.
I have removed the AgressiveInlining option as it does not seem relevant anymore.